Sprite 1984

home *** CD-ROM | disk | FTP | other *** search

/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / machserver / include / user / RCS / sync.h,v < prev next >

Wrap

Text File | 1992-07-17 | 10.8 KB | 398 lines

head 1.7; branch ; access ; symbols srv030:1.7 srv027:1.7 srv026:1.7 srv024:1.7 srv021:1.7 srv019:1.7 srv018:1.7 srv016:1.7 srv014:1.7 srv010:1.7 srv008:1.7 srv007:1.7 srv006:1.6 srv005:1.6 srv004:1.6 srv003:1.6 srv002:1.6 srv001:1.6; locks ; strict; comment @ * @; 1.7 date 92.05.27.21.19.32; author kupfer; state Exp; branches ; next 1.6; 1.6 date 92.04.02.18.45.26; author kupfer; state Exp; branches ; next 1.5; 1.5 date 91.11.11.23.12.39; author kupfer; state Exp; branches ; next 1.4; 1.4 date 91.09.24.19.47.19; author kupfer; state Exp; branches ; next 1.3; 1.3 date 91.08.30.16.10.03; author kupfer; state Exp; branches ; next 1.2; 1.2 date 91.08.15.18.33.56; author kupfer; state Exp; branches ; next 1.1; 1.1 date 91.08.07.11.29.33; author kupfer; state Exp; branches ; next ; desc @@ 1.7 log @Add dynamicName flag to Sync_Condition. @ text @/* * sync.h -- * * Typedefs and macros to support the use of monitors. * Clients use the macros to acquire and release monitor locks, and * to wait on and notify monitored condition variables. Only Broadcast * semantics are supported for lock release; that is, all processes * waiting on a lock are made runnable when the locked is released. * * Copyright 1986, 1988, 1991 Regents of the University of California * Permission to use, copy, modify, and distribute this * software and its documentation for any purpose and without * fee is hereby granted, provided that the above copyright * notice appear in all copies. The University of California * makes no representations about the suitability of this * software for any purpose. It is provided "as is" without * express or implied warranty. * * * $Header: /user5/kupfer/spriteserver/include/user/RCS/sync.h,v 1.6 92/04/02 18:45:26 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) */ #ifndef _SYNCUSER #define _SYNCUSER #include <sprite.h> #include <cthreads.h> /* * Dummy definition for a user lock. This is to keep the compiler happy * when dealing with programs that include Sprite server header files. It * needs to be fixed whenever we get around to supporting multi-threaded * user programs. */ typedef int Sync_UserLock; #if !defined(KERNEL) && !defined(SPRITED) typedef Sync_UserLock Sync_Lock; #endif /* * Condition variables represent events that are associated with * locks. The operations on a condition variable are Sync_Wait and * Sync_Broadcast. The lock must be acquired before a call to * Sync_Wait is made. The lock is released while a process waits on a * condition, and is then re-acquired when the condition is notified * via Sync_Broadcast. * * For the Sprite server we basically just use a C Threads condition * variable. The "initialized" flag is used for compatibility with * native Sprite code, which doesn't require that condition variables be * initialized before use. */ typedef struct Sync_Condition { struct condition condVar; Boolean initialized; Boolean dynamicName; /* does c.v. name need freeing */ } Sync_Condition; /* * Maximum number of prior locks that can exist for any type of lock. A prior * lock is the last lock to be grabbed by the process grabbing the current * lock. Keeping track of the locks held by a process is done in the proc * module. By knowing all the prior locks of a lock it is possible to * construct a tree representing the locking behavior of the system. * SYNC_MAX_PRIOR places a limit on how many prior locks will be remembered * for an individual lock. */ #ifndef LOCKDEP #define SYNC_MAX_PRIOR 1 #else #define SYNC_MAX_PRIOR 30 #endif /* * This structure is used to pass locking statistics to user programs. * One of these structures is needed per lock type. */ typedef struct { int inUse; /* 1 if structure is valid */ int class; /* 0 = semaphore, 1 = lock */ int hit; /* # times lock was grabbed */ int miss; /* # times lock was missed */ char name[30]; /* name of lock */ int priorCount; /* # of prior locks */ int priorTypes[SYNC_MAX_PRIOR]; /* types of prior locks */ int activeCount; /* # active locks of type */ int deadCount; /* # dead locks of type */ int spinCount; /* # spins waiting for lock */ } Sync_LockStat; /* * ---------------------------------------------------------------------------- * * Monitor Locks -- * * The following set of macros are used to emulate monitored * procedures of Mesa. The Sprite style document has a complete * description of the conventions required to emulate a set * of monitored procedures; a summary is presented here. * * The LOCK_MONITOR and UNLOCK_MONITOR macros depend on a constant * LOCKPTR. LOCKPTR should be defined as the address of the lock * variable used to lock the monitor. Something like the following * two lines of code should appear at the beginning of a file of * monitored procedures. * * Sync_Lock modMonitorLock; * #define LOCKPTR (&modMonitorLock) * * The pseudo-keywords INTERNAL and ENTRY denote internal and entry * procedures of a monitor. INTERNAL procedures can only be called * when the monitor lock is held. ENTRY procedures are procedures * that acquire the lock. There may also be External procedures. * They are the default and there is no special keyword. An External * procedure doesn't explicitly acquire the monitor lock, but may * call an ENTRY procedure. * * ---------------------------------------------------------------------------- */ /* XXX disable monitors for user code. */ #ifdef SPRITED #define LOCK_MONITOR (void) Sync_GetLock(LOCKPTR) #define UNLOCK_MONITOR (void) Sync_Unlock(LOCKPTR) #else #define LOCK_MONITOR #define UNLOCK_MONITOR #endif #define ENTRY #define INTERNAL /* * ---------------------------------------------------------------------------- * * Sync_Wait -- * * Wait on a condition variable. This can only be called while a lock * is aquired because it is only safe to check global state while in a * monitor. This releases the monitor lock and makes the process sleep * on the condition. The monitor lock is reacquired after the process * has been woken up. * * The address of the condition variable is used as the generic 'event' * that the process blocks on. The value of the condition variable is * used to indicate if there is a process waiting on the condition. * * Results: * None. * * Side effects: * Put the process to sleep and release the monitor lock. * * ---------------------------------------------------------------------------- */ #define Sync_Wait(conditionPtr, wakeIfSignal) \ Sync_SlowWait(conditionPtr, LOCKPTR, wakeIfSignal) /* * ---------------------------------------------------------------------------- * * Sync_Broadcast -- * * Notify other processes that a condition has been met (this is * the version for user processes only). * * Monitor Lock: * This routine needs to be called with the monitor lock held. * This ensures synchronous access to the conditionPtr->waiting flag. * * Results: * None. * * Side effects: * Make the processes waiting on the condition variable runnable. * * ---------------------------------------------------------------------------- */ #ifndef SPRITED #define Sync_Broadcast(conditionPtr) \ if (((Sync_Condition *)conditionPtr)->waiting == TRUE) { \ (void)Sync_SlowBroadcast((unsigned int) conditionPtr, \ &((Sync_Condition *)conditionPtr)->waiting); \ } #endif /* * Exported procedures of the sync module for monitors. */ #if !defined(KERNEL) && !defined(SPRITED) extern ReturnStatus Sync_GetLock(); extern ReturnStatus Sync_Unlock(); #endif extern ReturnStatus Sync_SlowLock(); extern ReturnStatus Sync_SlowWait(); extern ReturnStatus Sync_SlowBroadcast(); #endif /* _SYNCUSER */ @ 1.6 log @Add dummy definition for Sync_UserLock. @ text @d20 1 a20 1 * $Header: /user5/kupfer/spriteserver/include/user/RCS/sync.h,v 1.5 91/11/11 23:12:39 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) d59 1 @ 1.5 log @Condition variables might not be initially bzero'd. Also, be careful about conflicting user/server declarations for lock/unlock. @ text @d20 1 a20 1 * $Header: /r3/kupfer/spriteserver/include/user/RCS/sync.h,v 1.4 91/09/24 19:47:19 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) d28 13 @ 1.4 log @Turn on condition variables. @ text @d20 1 a20 1 * $Header: /user6/kupfer/spriteserver/include/user/RCS/sync.h,v 1.3 91/08/30 16:10:03 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) d39 2 a40 2 * native Sprite code that assumed that a zero'd Sync_Condition would * be sufficiently initialized. d186 1 d189 1 @ 1.3 log @Disable monitors for user code. @ text @d20 1 a20 1 * $Header: /user6/kupfer/spriteserver/include/user/RCS/sync.h,v 1.2 91/08/15 18:33:56 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) a148 1 #if 0 a150 1 #endif d158 2 a159 4 * Notify other processes that a condition has been met. If the * condition variable indicates that there are processes waiting * on the condition, then Sync_SlowBroadcast is used to wakeup * waiting processes. d174 1 a174 1 #if 0 @ 1.2 log @Initial changes for use on top of C Threads. @ text @d20 1 a20 1 * $Header: /user6/kupfer/spriteserver/include/user/RCS/sync.h,v 1.1 91/08/07 11:29:33 kupfer Exp Locker: kupfer $ SPRITE (Berkeley) d112 2 d116 4 @ 1.1 log @Initial revision @ text @d10 1 a10 6 * These macros do a fast check on the state of the lock or condition * variable to reduce overhead. In the best case the lock and unlock * routines just set or clear flags. In the worst case these routines * have to call slower routines that must acquire a master lock. * * Copyright 1986, 1988 Regents of the University of California d20 1 a20 1 * $Header: /sprite/src/lib/include/RCS/sync.h,v 1.7 90/01/16 17:59:49 jhh Exp $ SPRITE (Berkeley) d26 2 a27 27 #ifndef _SPRITE #include "sprite.h" #endif /* * The state of a lock consists of two bits of information, a lock bit * and a waiting bit. The lock bit indicates that someone has the * lock, and no other process can acquire the lock until this bit is * cleared. The waiting bit indicates that someone wants the lock. * * The user locks are different from the kernel locks. If we are compiling * user code then the Sync_UserLock type is typedef'ed to be Sync_Lock. * The Sync_UserLock type is used by the kernel to differentiate between * the two types of locks. * * Note: the inUse field is a whole word so it can be * an argument to the test-and-set instruction. */ typedef struct Sync_UserLock { Boolean inUse; /* 1 while the lock is busy */ Boolean waiting; /* 1 if someone wants the lock */ } Sync_UserLock; #ifndef KERNEL typedef Sync_UserLock Sync_Lock; /* define user locks */ #endif d36 5 d44 2 a45 1 Boolean waiting; /* 1 if someone is waiting on the condition */ d143 1 d146 1 d172 1 d178 1 @